﻿#include <iostream>
using namespace std;

typedef int STDataType;
class Stack
{
public:
	/*Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
				return;
		}
		_capacity = n;
		_top = 0;
	}*/

private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

// 两个Stack实现队列
class MyQueue
{
public:
	//编译器默认⽣成 MyQueue 的构造函数调用了Stack的构造，完成了两个成员的初始化

private:
	Stack pushst;
	Stack popst;
};

int main()
{
	MyQueue q;

	return 0;
}




//class Date
//{
//public:
//	//不写构造函数，编译器会自动生成一个无参的默认构造函数。
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
//int main()
//{
//	Date a;
//	a.Print();
//
//	return 0;
//}





//#include <iostream>
//using namespace std;
//
//class Date
//{
//public:
//	//构造函数
//	//3.全缺省构造函数，与无参构造函数产生歧义，因此不能与无参构造函数并存
//	/*Date(int year = 1970, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}*/
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
//int main()
//{
//	Date a;
//	a.Print();
//
//	return 0;
//}



//#include <iostream>
//using namespace std;
//
//class Date
//{
//public:
//	//构造函数
//	//1.无参构造函数
//	Date()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}
//
//	////2.带参构造函数，与无参构造函数形成重载函数，因此这两种构造可以并存
//	//Date(int year, int month, int day)
//	//{
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
//	//}
//
//	////3.全缺省构造函数，与无参构造函数产生歧义，因此不能与无参构造函数并存
//	//Date(int year = 1970, int month = 1, int day = 1)
//	//{
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
//	//}
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
//int main()
//{
//	Date a;
//	Date b();
//
//	//a.Print();
//	//b.Print();
//
//	return 0;
//}
//
//





//#include <iostream>
//#include <assert.h>
//using namespace std;
//
//typedef int STDateType;
//class Stack
//{
//public:
//	//初始化
//	void Init(int n = 4)
//	{
//		_a = (STDateType*)malloc(sizeof(STDateType) * n);
//		if (_a == nullptr)
//		{
//			perror("malloc fail!");
//			exit(1);
//		}
//
//		_capacity = n;
//		_top = 0;
//	}
//
//	//插入
//	void Push(STDateType x)
//	{
//		//判断是否扩容
//		if (_top == _capacity)
//		{
//			size_t newCapacity = _capacity * 2;
//			STDateType* tmp = (STDateType*)realloc(_a, newCapacity * sizeof(STDateType));
//			if (tmp == nullptr)
//			{
//				perror("realloc fail!");
//				exit(1);
//			}
//
//			_a = tmp;
//			_capacity = newCapacity;
//		}
//
//		_a[_top++] = x;
//	}
//
//	//删除
//	void Pop()
//	{
//		assert(_top > 0);
//		--_top;
//	}
//
//	//判空
//	bool Empty()
//	{
//		return _top == 0;
//	}
//
//	//取栈顶元素
//	STDateType Top()
//	{
//		assert(_top > 0);
//		return _a[_top - 1];
//	}
//
//	//销毁
//	void Destroy()
//	{
//		free(_a);
//		_a = nullptr;
//		_capacity = _top = 0;
//	}
//
//private:
//	//成员变量
//	STDateType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//
//int main()
//{
//	Stack st;
//	st.Init();
//
//	st.Push(1);
//	st.Push(2);
//	st.Push(3);
//	st.Push(4);
//	st.Push(5);
//
//	while (!(st.Empty()))
//	{
//		cout << st.Top() << endl;
//		st.Pop();
//	}
//
//	st.Destroy();
//
//	return 0;
//}
//





//#include <iostream>
//using namespace std;
//
//class A
//{
//public:
//	void Print()
//	{
//		cout << "A::Print()" << endl;
//		cout << this->_a << endl;
//	}
//private:
//	int _a;
//};
//
//int main()
//{
//	A* p = nullptr;
//	p->Print();
//
//	return 0;
//}

//using namespace std;
//
//class A
//{
//public:
//	void Print()
//	{
//		cout << "A::Print()" << endl;
//	}
//private:
//	int _a;
//};
//
//int main()
//{
//	A* p = nullptr;
//	p->Print();
//
//	return 0;
//}